/**
 *
    算法描述：通过列举出15以内的火柴数目可发现，本题能够通过DP来实现。最终答案可以变成研究前面子问题答案的结果
    解决所需数据结构+算法：数组 + 动规
**/
#include<iostream>
#include<queue>
#include<vector>
#include<cmath>
#define Queue priority_queue<int, vector<int>, greater<int>> // 小根堆别名

using namespace std;

struct Node {
    int len, ans; // len 为位数，ans 存放最小的答案，ans决定了是否刷新dp的值
    Queue q;

    void geta() {
        // q.push(6); // geta测试
        ans = len = 0;
        int a, count = 0; // count计0数
        Queue qq = q; // 必加，不然每次被删掉
        while(qq.size()) {
            int a = qq.top();
            qq.pop();
            if(a) { // 不为0的情况
                ans = ans * 10 + a;
                for(; count; count--)   ans *= 10; // 处理0的个数
            } else {
                count++;
            }
            len++;
        }
        if(count) { // 如果count未被处理成0，说明是全0的情况，此时len符合情况，无需修改
            ans = 6 * pow(10, count - 1);
        }
    }
};

int max(int x, int y) {return x > y ? x : y;}

//            {6, 2, 5, 5, 4, 5, 6, 3, 7, 6}   每个数字对应的火柴数目
int k[8] = {6, -1, 1, 7, 4, 2, 0, 8};
int mx = -1; // 输入的最大值

int main() {
    int T, n;
    Node dp[100010];


    // cin >> T;
    // int num[55];
    // for(int i=0; i<T; i++) {
    //     cin >> num[i];
    //     mx = max(mx, num[i]);
    // }

    for(int i=2; i<=100; i++) { // 测试
    // for(int i=2; i<=mx; i++) {
        if(i < 8) {
            dp[i].q.push(k[i]);
            dp[i].geta();
        } else {
            for(int j=2; j<=i/2; j++) { // 2开始才有值，到一半就结束，因为前后队列合并一样的
                /**
                 * 四种情况：
                 *      1.如果第i个dp值被更新过，并且后面的要大于前面的位数，直接跳过
                 *      2.如果第i个dp值大于后面的，直接合并队列
                 *      3.未被更新，直接合并队列（可与2合体
                 *      4.长度相等，需要对ans值进行判断
                 */
                if(dp[i].len!=0 && dp[j].len + dp[i-j].len > dp[i].len) continue;
                if(!dp[i].len || dp[i].len > dp[j].len + dp[i-j].len) {
                    while(dp[i].q.size()) dp[i].q.pop();
                    Queue qj = dp[j].q, qij = dp[i-j].q;
                    while(qj.size())    dp[i].q.push(qj.top()), qj.pop();
                    while(qij.size())   dp[i].q.push(qij.top()), qij.pop();
                    dp[i].geta();
                    // cout << dp[i].len << "  初始化：" << dp[i].ans << endl;
                    continue;
                }
                Node node; // 用于比较的临时变量
                Queue qj = dp[j].q, qij = dp[i-j].q;
                while(qj.size())    node.q.push(qj.top()), qj.pop();
                while(qij.size())   node.q.push(qij.top()), qij.pop();
                node.geta();
                if(node.ans < dp[i].ans)    dp[i] = node; // 出现更小值，则更新
                // cout << "---run------" << endl;
            }
        }
    }

    for(int i=1; i<=100; i++) {
        cout << dp[i].ans << endl;
    }


    // for(int i=0; i<T; i++) {
    //     if(num[i] < 2)  cout << -1 << endl;
    //     else cout << dp[num[i]].ans << endl;
    // }

    return 0;
}